#include <iostream>
#include <queue>
#include <vector>
#include <thread>
#include <chrono>

using namespace std;

// AGV类
class AGV {
public:
    AGV(int id) : id(id), pos(0), loaded(false) {}

    // 移动到指定位置
    void move(int dest) {
        // 模拟移动过程
        int distance = abs(dest - pos);
        cout << "AGV" << id << " moving to " << dest << ", distance: " << distance << endl;
        for (int i = 0; i < distance; ++i) {
            this_thread::sleep_for(chrono::milliseconds(100));
        }
        pos = dest;
    }

    // 装载货物
    void load() {
        cout << "AGV" << id << " loading..." << endl;
        loaded = true;
        // 模拟装载时间
        this_thread::sleep_for(chrono::milliseconds(500));
    }

    // 卸载货物
    void unload() {
        cout << "AGV" << id << " unloading..." << endl;
        loaded = false;
        // 模拟卸载时间
        this_thread::sleep_for(chrono::milliseconds(500));
    }

    // 获取AGV编号
    int getId() const {
        return id;
    }

    // 获取AGV位置
    int getpos() const {
        return pos;
    }

    // 获取AGV状态（是否有货物）
    bool isLoaded() const {
        return loaded;
    }

private:
    int id; // AGV编号
    int pos; // AGV位置
    bool loaded; // 货物状态
};

// 任务类
class Task {
public:
    Task(int id, int from, int to, int loadTime) : id(id), from(from), to(to), loadTime(loadTime) {}

    // 获取任务编号
    int getId() const {
        return id;
    }

    // 获取任务起始位置
    int getFrom() const {
        return from;
    }

    // 获取任务目标位置
    int getTo() const {
        return to;
    }

    // 获取装载时间
    int getLoadTime() const {
        return loadTime;
    }

private:
    int id; // 任务编号
    int from; // 起始位置
    int to; // 目标位置
    int loadTime; // 装载时间
};

// 任务队列类
class TaskQueue {
public:
    // 添加任务
    void addTask(const Task& task) {
        tasks.push(task);
    }

    // 获取下一个任务
    Task getNextTask() {
        Task task = tasks.front();
        tasks.pop();
        return task;
    }

    // 判断任务队列是否为空
    bool empty() const {
        return tasks.empty();
    }

private:
    queue<Task> tasks; // 任务队列
};

// AGV调度器类
class Scheduler {
public:
    Scheduler(int agvNum) {
        for (int i = 0; i < agvNum; ++i) {
            AGV agv(i);
            agvs.push_back(agv);
        }
    }

    // 添加任务
    void addTask(const Task& task) {
        taskQueue.addTask(task);
    }

    // 开始调度
    void start() {
        while (!taskQueue.empty()) {
            Task task = taskQueue.getNextTask();
            AGV& agv = getAvailableAGV();
            int distance = abs(agv.getpos() - task.getFrom());
            cout << "AGV" << agv.getId() << " distance: " << distance << endl;
            agv.move(task.getFrom());
            agv.load();
            // 等待装载时间
            this_thread::sleep_for(chrono::milliseconds(task.getLoadTime()));
            agv.move(task.getTo());
            agv.unload();
        }
    }

private:
    // 获取空闲的AGV
    AGV& getAvailableAGV() {
        for (AGV& agv : agvs) {
            if (!agv.isLoaded()) {
                return agv;
            }
        }
        // 如果没有空闲的AGV，则等待一段时间再重试
        this_thread::sleep_for(chrono::milliseconds(100));
        return getAvailableAGV();
    }

    vector<AGV> agvs; // AGV[列表]
    TaskQueue taskQueue; // 任务队列
};

int main() {
    // 创建调度器，初始化3个AGV
    Scheduler scheduler(3);

    // 添加任务
    Task task1(1, 0, 5, 1000); // 从位置0到位置5，装载时间1000ms
    Task task2(2, 5, 2, 500); // 从位置5到位置2，装载时间500ms
    Task task3(3, 2, 8, 800); // 从位置2到位置8，装载时间800ms
    scheduler.addTask(task1);
    scheduler.addTask(task2);
    scheduler.addTask(task3);

    // 开始调度
    scheduler.start();

    return 0;
}